home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Programming / Python1.4_Source / Objects / sliceobject.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-24  |  3.8 KB  |  186 lines
  1. /*
  2. Written by Jim Hugunin and Chris Chase.
  3.  
  4. This includes both the singular ellipsis object and slice objects.
  5.  
  6. Guido, feel free to do whatever you want in the way of copyrights
  7. for this file.
  8. */
  9.  
  10. /* 
  11. Py_Ellipsis encodes the '...' rubber index token. It is similar to
  12. the Py_NoneStruct in that there is no way to create other objects of
  13. this type and there is exactly one in existence.
  14. */
  15.  
  16. #include "Python.h"
  17. #include "protos/sliceobject_protos.h"
  18.  
  19. static PyObject *
  20. ellipsis_repr(op)
  21.     PyObject *op;
  22. {
  23.     return PyString_FromString("Ellipsis");
  24. }
  25.  
  26. static PyTypeObject PyEllipsis_Type = {
  27.     PyObject_HEAD_INIT(&PyType_Type)
  28.     0,
  29.     "ellipsis",
  30.     0,
  31.     0,
  32.     0,        /*tp_dealloc*/ /*never called*/
  33.     0,        /*tp_print*/
  34.     0,        /*tp_getattr*/
  35.     0,        /*tp_setattr*/
  36.     0,        /*tp_compare*/
  37.     (reprfunc)ellipsis_repr, /*tp_repr*/
  38.     0,        /*tp_as_number*/
  39.     0,        /*tp_as_sequence*/
  40.     0,        /*tp_as_mapping*/
  41.     0,        /*tp_hash */
  42. };
  43.  
  44. PyObject _Py_EllipsisObject = {
  45.     PyObject_HEAD_INIT(&PyEllipsis_Type)
  46. };
  47.  
  48.  
  49. /* Slice object implementation
  50.  
  51.    start, stop, and step are python objects with None indicating no
  52.    index is present.
  53. */
  54.  
  55. PyObject *
  56. PySlice_New(start, stop, step)
  57.     PyObject *start;
  58.     PyObject *stop;
  59.     PyObject *step;
  60. {
  61.     PySliceObject *obj =
  62.         (PySliceObject *) PyObject_NEW(PySliceObject, &PySlice_Type);
  63.  
  64.     if (step == NULL) step = Py_None;
  65.     Py_INCREF(step);
  66.     if (start == NULL) start = Py_None;
  67.     Py_INCREF(start);
  68.     if (stop == NULL) stop = Py_None;
  69.     Py_INCREF(stop);
  70.  
  71.     obj->step = step;
  72.     obj->start = start;
  73.     obj->stop = stop;
  74.  
  75.     return (PyObject *) obj;
  76. }
  77.  
  78. int
  79. PySlice_GetIndices(r, length, start, stop, step)
  80.     PySliceObject *r;
  81.     int length;
  82.     int *start;
  83.     int *stop;
  84.     int *step;
  85. {
  86.     if (r->step == Py_None) {
  87.         *step = 1;
  88.     } else {
  89.         if (!PyInt_Check(r->step)) return -1;
  90.         *step = PyInt_AsLong(r->step);
  91.     }
  92.     if (r->start == Py_None) {
  93.         *start = *step < 0 ? length-1 : 0;
  94.     } else {
  95.         if (!PyInt_Check(r->start)) return -1;
  96.         *start = PyInt_AsLong(r->start);
  97.         if (*start < 0) *start += length;
  98.     }
  99.     if (r->stop == Py_None) {
  100.         *stop = *step < 0 ? -1 : length;
  101.     } else {
  102.         if (!PyInt_Check(r->stop)) return -1;
  103.         *stop = PyInt_AsLong(r->stop);
  104.         if (*stop < 0) *stop += length;
  105.     }
  106.     if (*stop > length) return -1;
  107.     if (*start >= length) return -1;
  108.     if (*step == 0) return -1;
  109.     return 0;
  110. }
  111.  
  112. static void
  113. slice_dealloc(r)
  114.     PySliceObject *r;
  115. {
  116.     Py_DECREF(r->step);
  117.     Py_DECREF(r->start);
  118.     Py_DECREF(r->stop);
  119.     PyMem_DEL(r);
  120. }
  121.  
  122. static PyObject *
  123. slice_repr(r)
  124.     PySliceObject *r;
  125. {
  126.     PyObject *s, *comma;
  127.  
  128.     s = PyString_FromString("slice(");
  129.     comma = PyString_FromString(", ");
  130.     PyString_ConcatAndDel(&s, PyObject_Repr(r->start));
  131.     PyString_Concat(&s, comma);
  132.     PyString_ConcatAndDel(&s, PyObject_Repr(r->stop));
  133.     PyString_Concat(&s, comma);
  134.     PyString_ConcatAndDel(&s, PyObject_Repr(r->step));
  135.     PyString_ConcatAndDel(&s, PyString_FromString(")"));
  136.     Py_DECREF(comma);
  137.     return s;
  138. }
  139.  
  140.  
  141. static PyObject *slice_getattr(self, name)
  142.     PySliceObject *self;
  143.     char *name;
  144. {
  145.     PyObject *ret;
  146.   
  147.     ret = NULL;
  148.     if (strcmp(name, "start") == 0) {
  149.         ret = self->start;
  150.     }
  151.     else if (strcmp(name, "stop") == 0) {
  152.         ret = self->stop;
  153.     }
  154.     else if (strcmp(name, "step") == 0) {
  155.         ret = self->step;
  156.     }
  157.     else if (strcmp(name, "__members__") == 0) {
  158.         return Py_BuildValue("[sss]",
  159.                      "start", "stop", "step");
  160.     }
  161.     else {
  162.         PyErr_SetString(PyExc_AttributeError, name);
  163.         return NULL;
  164.     }
  165.     Py_INCREF(ret);
  166.     return ret;
  167. }
  168.  
  169.  
  170. PyTypeObject PySlice_Type = {
  171.     PyObject_HEAD_INIT(&PyType_Type)
  172.     0,            /* Number of items for varobject */
  173.     "slice",        /* Name of this type */
  174.     sizeof(PySliceObject),    /* Basic object size */
  175.     0,            /* Item size for varobject */
  176.     (destructor)slice_dealloc, /*tp_dealloc*/
  177.     0,            /*tp_print*/
  178.     (getattrfunc)slice_getattr, /*tp_getattr*/
  179.     0,            /*tp_setattr*/
  180.     0,            /*tp_compare*/
  181.     (reprfunc)slice_repr, /*tp_repr*/
  182.     0,            /*tp_as_number*/
  183.     0,            /*tp_as_sequence*/
  184.     0,            /*tp_as_mapping*/
  185. };
  186.